/*
 * Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */

package org.box2dflash.common {
	import org.box2dflash.common.math.Vec2;

	public class Settings {
		static public const USHRT_MAX:int = 0x0000ffff;
		static public const _pi:Number = Math.PI;
		// Collision
		static public const _maxManifoldPoints:int = 2;
		static public const _maxPolygonVertices:int = 8;
		static public const _maxProxies:int = 512;				
		// this must be a power of two
		static public const _maxPairs:int = 8 * _maxProxies;	
		// this must be a power of two



		// Dynamics
	
		/// A small length used as a collision and constraint tolerance. Usually it is
		/// chosen to be numerically significant, but visually insignificant.
		static public const _linearSlop:Number = 0.005;	
		// 0.5 cm
	
		/// A small angle used as a collision and constraint tolerance. Usually it is
		/// chosen to be numerically significant, but visually insignificant.
		static public const _angularSlop:Number = 2.0 / 180.0 * _pi;			
		// 2 degrees
	
		/// Continuous collision detection (CCD) works with core, shrunken shapes. This is the
		/// amount by which shapes are automatically shrunk to work with CCD. This must be
		/// larger than _linearSlop.
		static public const _toiSlop:Number = 8.0 * _linearSlop;
		/// Maximum number of contacts to be handled to solve a TOI island.
		static public const _maxTOIContactsPerIsland:int = 32;
		/// A velocity threshold for elastic collisions. Any collision with a relative linear
		/// velocity below this threshold will be treated as inelastic.
		static public const _velocityThreshold:Number = 1.0;		
		// 1 m/s
	
		/// The maximum linear position correction used when solving constraints. This helps to
		/// prevent overshoot.
		static public const _maxLinearCorrection:Number = 0.2;	
		// 20 cm
	
		/// The maximum angular position correction used when solving constraints. This helps to
		/// prevent overshoot.
		static public const _maxAngularCorrection:Number = 8.0 / 180.0 * _pi;			
		// 8 degrees
	
		/// The maximum linear velocity of a body. This limit is very large and is used
		/// to prevent numerical problems. You shouldn't need to adjust this.
		static public const _maxLinearVelocity:Number = 200.0;
		static public const _maxLinearVelocitySquared:Number = _maxLinearVelocity * _maxLinearVelocity;
		/// The maximum angular velocity of a body. This limit is very large and is used
		/// to prevent numerical problems. You shouldn't need to adjust this.
		static public const _maxAngularVelocity:Number = 250.0;
		static public const _maxAngularVelocitySquared:Number = _maxAngularVelocity * _maxAngularVelocity;
		/// This scale factor controls how fast overlap is resolved. Ideally this would be 1 so
		/// that overlap is removed in one time step. However using values close to 1 often lead
		/// to overshoot.
		static public const _contactBaumgarte:Number = 0.2;
		// Sleep
	
		/// The time that a body must be still before it will go to sleep.
		static public const _timeToSleep:Number = 0.5;					
		// half a second
		/// A body cannot sleep if its linear velocity is above this tolerance.
		static public const _linearSleepTolerance:Number = 0.01;			
		// 1 cm/s
		/// A body cannot sleep if its angular velocity is above this tolerance.
		static public const _angularSleepTolerance:Number = 2.0 / 180.0;	
		
		// 2 degrees/s
	
		// assert
		static public function Assert(a:Boolean):void {
			if (!a) {
				var nullVec:Vec2;
				nullVec.x++;
			}
		}
	}
}